// 声破天音乐库JavaScript

document.addEventListener('DOMContentLoaded', function() {
    // 初始化多语言支持
    if (window.i18n) {
        window.i18n.initLanguage();
    } else {
        console.error('国际化模块未加载！');
    }
    
    // 初始化播放列表管理
    initPlaylistManager();
    
    // 初始化标签切换
    initLibraryTabs();
    
    // 初始化筛选按钮
    initFilterButtons();
    
    // 初始化搜索功能
    initLibrarySearch();
    
    // 初始化卡片悬停效果
    initCardHoverEffects();
    
    // 初始化播放按钮
    initPlayButtons();
    
    // 加载用户数据并更新界面
    loadUserDataAndUpdateUI();
    
    // 初始化播放器交互
    initPlayerInteractions();

    // 检查登录状态
    checkLoginStatus();

    // 初始化顶部栏滚动隐藏
    initTopBarScrollHandling();
});

// 初始化播放列表管理
function initPlaylistManager() {
    // 创建全局播放列表对象
    window.playlistManager = {
        currentPlaylist: [], // 当前播放列表
        currentIndex: -1,    // 当前播放索引
        shuffle: false,      // 是否随机播放
        repeat: false,       // 是否循环播放
        
        // 添加歌曲到播放列表
        addTrack: function(track) {
            this.currentPlaylist.push(track);
            console.log('已添加到播放列表:', track.title);
        },
        
        // 设置当前播放列表并开始播放
        setPlaylist: function(tracks, startIndex = 0) {
            this.currentPlaylist = tracks;
            this.currentIndex = startIndex;
            this.playCurrentTrack();
            console.log('已设置播放列表，共', tracks.length, '首歌曲');
        },
        
        // 播放当前曲目
        playCurrentTrack: function() {
            if (this.currentPlaylist.length === 0 || this.currentIndex < 0) {
                console.log('播放列表为空或索引无效');
                return;
            }
            
            const track = this.currentPlaylist[this.currentIndex];
            console.log('正在播放:', track.title, '- 索引:', this.currentIndex);
            
            // 更新播放器UI
            updatePlayerUI({
                title: track.title,
                artist: track.artist,
                coverUrl: track.coverUrl
            });
            
            // 设置音频源
            if (window.audioPlayer) {
                window.audioPlayer.src = track.audioSrc;
                togglePlayPause(true); // 开始播放
            }
        },
        
        // 播放下一首
        next: function() {
            if (this.currentPlaylist.length === 0) return;
            
            if (this.shuffle) {
                // 随机播放模式
                const nextIndex = Math.floor(Math.random() * this.currentPlaylist.length);
                this.currentIndex = nextIndex;
            } else {
                // 顺序播放模式
                this.currentIndex = (this.currentIndex + 1) % this.currentPlaylist.length;
            }
            
            this.playCurrentTrack();
        },
        
        // 播放上一首
        previous: function() {
            if (this.currentPlaylist.length === 0) return;
            
            if (this.shuffle) {
                // 随机播放模式
                const nextIndex = Math.floor(Math.random() * this.currentPlaylist.length);
                this.currentIndex = nextIndex;
            } else {
                // 顺序播放模式
                this.currentIndex = (this.currentIndex - 1 + this.currentPlaylist.length) % this.currentPlaylist.length;
            }
            
            this.playCurrentTrack();
        },
        
        // 切换随机播放
        toggleShuffle: function() {
            this.shuffle = !this.shuffle;
            return this.shuffle;
        },
        
        // 切换循环播放
        toggleRepeat: function() {
            this.repeat = !this.repeat;
            return this.repeat;
        }
    };
    
    // 如果存在音频播放器，设置播放结束事件
    if (window.audioPlayer) {
        window.audioPlayer.addEventListener('ended', function() {
            // 检查是否循环播放
            if (window.playlistManager.repeat) {
                // 重新播放当前歌曲
                window.audioPlayer.currentTime = 0;
                window.audioPlayer.play().catch(e => console.log('自动播放失败:', e));
            } else {
                // 播放下一首
                window.playlistManager.next();
            }
        });
    }
}

// 初始化标签切换
function initLibraryTabs() {
    const tabs = document.querySelectorAll('.library-tab');
    const tabContents = document.querySelectorAll('.tab-content');
    
    tabs.forEach(tab => {
        tab.addEventListener('click', function() {
            // 获取标签对应的内容ID
            const tabId = this.getAttribute('data-tab');
            
            // 移除所有标签的活动状态
            tabs.forEach(t => t.classList.remove('active'));
            
            // 激活当前标签
            this.classList.add('active');
            
            // 隐藏所有内容
            tabContents.forEach(content => content.classList.remove('active'));
            
            // 显示当前标签对应的内容
            const activeContent = document.querySelector(`.${tabId}-tab`);
            if (activeContent) {
                activeContent.classList.add('active');
            }
        });
    });
}

// 初始化筛选按钮
function initFilterButtons() {
    const filterBtn = document.querySelector('.filter-btn');
    const sortBtn = document.querySelector('.sort-btn');
    
    if (filterBtn) {
        filterBtn.addEventListener('click', function() {
            // 这里可以实现筛选功能，例如显示一个筛选弹窗
            console.log('筛选按钮被点击');
            alert('筛选功能即将上线');
        });
    }
    
    if (sortBtn) {
        sortBtn.addEventListener('click', function() {
            // 这里可以实现排序功能，例如显示排序选项
            console.log('排序按钮被点击');
            
            // 简单模拟不同排序方式的切换
            const sortText = this.querySelector('span');
            if (sortText) {
                if (sortText.textContent === '最近') {
                    sortText.textContent = '字母顺序';
                } else if (sortText.textContent === '字母顺序') {
                    sortText.textContent = '创建者';
                } else if (sortText.textContent === '创建者') {
                    sortText.textContent = '添加时间';
                } else {
                    sortText.textContent = '最近';
                }
            }
        });
    }
}

// 初始化音乐库搜索功能
function initLibrarySearch() {
    const searchBtn = document.querySelector('.search-lib-btn');
    
    if (searchBtn) {
        searchBtn.addEventListener('click', function() {
            // 创建搜索输入框
            if (!document.querySelector('.library-search-input')) {
                const filterButtons = document.querySelector('.filter-buttons');
                
                // 创建搜索输入容器
                const searchContainer = document.createElement('div');
                searchContainer.className = 'library-search-input';
                
                // 创建搜索输入框
                const searchInput = document.createElement('input');
                searchInput.type = 'text';
                searchInput.placeholder = '在音乐库中搜索';
                
                // 创建关闭按钮
                const closeBtn = document.createElement('button');
                closeBtn.className = 'close-search-btn';
                closeBtn.innerHTML = '<i class="fas fa-times"></i>';
                
                // 添加到容器
                searchContainer.appendChild(searchInput);
                searchContainer.appendChild(closeBtn);
                
                // 替换筛选按钮
                if (filterButtons) {
                    filterButtons.style.display = 'none';
                    filterButtons.parentNode.insertBefore(searchContainer, filterButtons);
                    
                    // 聚焦搜索框
                    searchInput.focus();
                    
                    // 添加搜索逻辑
                    searchInput.addEventListener('input', function() {
                        const searchTerm = this.value.toLowerCase();
                        searchInLibrary(searchTerm);
                    });
                    
                    // 关闭搜索
                    closeBtn.addEventListener('click', function() {
                        searchContainer.remove();
                        filterButtons.style.display = 'flex';
                    });
                }
            }
        });
    }
}

// 在音乐库中搜索
function searchInLibrary(searchTerm) {
    console.log('搜索:', searchTerm);
    
    // 获取当前活动的标签内容
    const activeTab = document.querySelector('.tab-content.active');
    if (!activeTab) return;
    
    // 搜索不同类型的卡片，根据标题搜索
    const cards = activeTab.querySelectorAll('.card, .artist-card');
    cards.forEach(card => {
        const title = card.querySelector('h3');
        if (title) {
            const titleText = title.textContent.toLowerCase();
            if (searchTerm === '' || titleText.includes(searchTerm)) {
                card.style.display = '';
            } else {
                card.style.display = 'none';
            }
        }
    });
}

// 初始化卡片悬停效果
function initCardHoverEffects() {
    const cards = document.querySelectorAll('.card, .artist-card');
    
    cards.forEach(card => {
        card.addEventListener('mouseenter', function() {
            const playButton = this.querySelector('.play-button');
            if (playButton) {
                playButton.style.transform = 'translateY(0)';
                playButton.style.opacity = '1';
            }
        });
        
        card.addEventListener('mouseleave', function() {
            const playButton = this.querySelector('.play-button');
            if (playButton) {
                playButton.style.transform = 'translateY(8px)';
                playButton.style.opacity = '0';
            }
        });
    });
}

// 初始化播放按钮
function initPlayButtons() {
    const playButtons = document.querySelectorAll('.play-button');
    
    playButtons.forEach(button => {
        button.addEventListener('click', function(e) {
            e.stopPropagation(); // 阻止事件冒泡
            
            // 获取卡片信息
            const card = this.closest('.card, .artist-card');
            if (!card) return;
            
            const title = card.querySelector('h3').textContent;
            const subtitle = card.querySelector('p').textContent;
            const imgElement = card.querySelector('img');
            const coverUrl = imgElement ? imgElement.src : '';
            
            // 设置当前音频源
            // 根据歌曲名称生成音频文件路径
            const audioFileName = title.toLowerCase().replace(/\s+/g, '_').replace(/[^\w\s]/gi, '');
            const audioSrc = `assets/music/${audioFileName}.mp3`;
            window.currentAudioSrc = audioSrc;
            
            // 创建曲目对象
            const track = {
                title: title,
                artist: subtitle.split('•')[0].trim(),
                coverUrl: coverUrl,
                audioSrc: audioSrc
            };
            
            // 检查是播放列表卡片还是单曲卡片
            const isPlaylist = subtitle.toLowerCase().includes('播放列表');
            
            if (isPlaylist) {
                // 如果是播放列表，可以加载该播放列表的歌曲（示例）
                const playlistTracks = generateSampleTracks(title);
                window.playlistManager.setPlaylist(playlistTracks, 0);
            } else {
                // 如果是单曲，添加到播放列表并播放
                window.playlistManager.setPlaylist([track], 0);
            }
            
            // 如果已有音频播放器，更新源
            if (window.audioPlayer) {
                window.audioPlayer.src = audioSrc;
            }
            
            // 更新播放器UI
            updatePlayerUI({
                title: title,
                artist: subtitle.split('•')[0].trim(),
                coverUrl: coverUrl
            });
            
            // 切换播放状态
            togglePlayPause(true); // true表示开始播放
            
            // 初始化进度条
            initProgressBar();
        });
    });
}

// 生成示例播放列表曲目（模拟数据）
function generateSampleTracks(playlistName) {
    // 这里可以根据实际需求从服务器获取播放列表数据
    // 这里仅做示例
    const sampleTracks = [];
    
    if (playlistName.includes('周杰伦')) {
        sampleTracks.push(
            {
                title: '晴天',
                artist: '周杰伦',
                coverUrl: 'assets/images/covers/cover2.jpg',
                audioSrc: 'assets/music/qingtian.mp3'
            },
            {
                title: '以父之名',
                artist: '周杰伦',
                coverUrl: 'assets/images/covers/cover2.jpg',
                audioSrc: 'assets/music/qingtian.mp3'
            },
            {
                title: '东风破',
                artist: '周杰伦',
                coverUrl: 'assets/images/covers/cover2.jpg',
                audioSrc: 'assets/music/qingtian.mp3'
            }
        );
    } else if (playlistName.includes('热门')) {
        sampleTracks.push(
            {
                title: '热门歌曲1',
                artist: '流行歌手1',
                coverUrl: 'assets/images/covers/cover3.jpg',
                audioSrc: 'assets/music/qingtian.mp3'
            },
            {
                title: '热门歌曲2',
                artist: '流行歌手2',
                coverUrl: 'assets/images/covers/cover4.jpg',
                audioSrc: 'assets/music/qingtian.mp3'
            }
        );
    } else {
        // 默认播放列表
        sampleTracks.push(
            {
                title: '示例歌曲1',
                artist: '艺术家1',
                coverUrl: 'assets/images/covers/cover1.jpg',
                audioSrc: 'assets/music/qingtian.mp3'
            },
            {
                title: '示例歌曲2',
                artist: '艺术家2',
                coverUrl: 'assets/images/covers/cover5.jpg',
                audioSrc: 'assets/music/qingtian.mp3'
            }
        );
    }
    
    return sampleTracks;
}

// 更新播放器UI
function updatePlayerUI(params) {
    const { title, artist, coverUrl } = params;
    
    // 更新播放器信息
    const nowPlayingCover = document.querySelector('.now-playing-cover img');
    const trackName = document.querySelector('.track-name');
    const artistName = document.querySelector('.artist-name');
    
    if (nowPlayingCover && coverUrl) {
        nowPlayingCover.src = coverUrl;
    }
    
    if (trackName) {
        trackName.textContent = title;
    }
    
    if (artistName) {
        artistName.textContent = artist;
    }
}

// 初始化播放器交互
function initPlayerInteractions() {
    const playPauseBtn = document.querySelector('.play-pause');
    const prevBtn = document.querySelector('.prev-btn');
    const nextBtn = document.querySelector('.next-btn');
    const shuffleBtn = document.querySelector('.shuffle-btn');
    const repeatBtn = document.querySelector('.repeat-btn');
    const likeBtn = document.querySelector('.like-track-btn');
    const volumeBtn = document.querySelector('.volume-btn');
    const volumeControl = document.querySelector('.volume-control');
    
    if (playPauseBtn) {
        playPauseBtn.addEventListener('click', () => togglePlayPause());
    }
    
    // 添加其他按钮的事件监听
    if (prevBtn) {
        prevBtn.addEventListener('click', () => playPreviousTrack());
    }
    
    if (nextBtn) {
        nextBtn.addEventListener('click', () => playNextTrack());
    }
    
    if (shuffleBtn) {
        shuffleBtn.addEventListener('click', function() {
            if (window.playlistManager) {
                const isShuffled = window.playlistManager.toggleShuffle();
                this.classList.toggle('active', isShuffled);
                console.log('随机播放:', isShuffled ? '开启' : '关闭');
            } else {
                this.classList.toggle('active');
                console.log('切换随机播放（播放列表管理器未初始化）');
            }
        });
    }
    
    if (repeatBtn) {
        repeatBtn.addEventListener('click', function() {
            if (window.playlistManager) {
                const isRepeated = window.playlistManager.toggleRepeat();
                this.classList.toggle('active', isRepeated);
                console.log('循环播放:', isRepeated ? '开启' : '关闭');
            } else {
                this.classList.toggle('active');
                console.log('切换重复播放（播放列表管理器未初始化）');
            }
        });
    }
    
    if (likeBtn) {
        likeBtn.addEventListener('click', function() {
            const icon = this.querySelector('i');
            if (icon) {
                icon.classList.toggle('fas');
                icon.classList.toggle('far');
                
                // 获取当前正在播放的歌曲信息
                if (window.playlistManager && window.playlistManager.currentPlaylist.length > 0) {
                    const currentTrack = window.playlistManager.currentPlaylist[window.playlistManager.currentIndex];
                    if (currentTrack) {
                        const isLiked = icon.classList.contains('fas');
                        console.log(`${isLiked ? '已收藏' : '取消收藏'} - ${currentTrack.title}`);
                        
                        // 这里可以添加保存到用户收藏的逻辑
                    }
                } else {
                    console.log('切换喜欢状态（无当前播放信息）');
                }
            }
        });
    }
    
    // 初始化音量控制
    initVolumeControl(volumeBtn, volumeControl);
}

// 初始化音量控制
function initVolumeControl(volumeBtn, volumeControl) {
    if (!volumeBtn || !volumeControl) return;
    
    // 获取音量滑块和音量图标
    const volumeSlider = volumeControl.querySelector('.volume-slider');
    const volumeIcon = volumeBtn.querySelector('i');
    
    // 如果元素不存在，则创建它们
    if (!volumeSlider) {
        // 创建音量控制滑块
        const slider = document.createElement('input');
        slider.type = 'range';
        slider.min = '0';
        slider.max = '100';
        slider.value = '70'; // 默认音量 70%
        slider.className = 'volume-slider';
        
        // 添加到音量控制容器
        volumeControl.appendChild(slider);
        
        // 更新音量滑块引用
        volumeSlider = slider;
    }
    
    // 初始音量设置（如果音频播放器存在）
    if (window.audioPlayer) {
        // 设置初始音量
        const initialVolume = 0.7; // 70%
        window.audioPlayer.volume = initialVolume;
        volumeSlider.value = initialVolume * 100;
    }
    
    // 添加音量按钮点击事件（静音切换）
    volumeBtn.addEventListener('click', function() {
        if (!window.audioPlayer) return;
        
        // 切换静音状态
        window.audioPlayer.muted = !window.audioPlayer.muted;
        
        // 更新图标
        if (window.audioPlayer.muted) {
            volumeIcon.className = 'fas fa-volume-mute';
        } else {
            updateVolumeIcon(window.audioPlayer.volume);
        }
    });
    
    // 添加音量滑块事件
    volumeSlider.addEventListener('input', function() {
        if (!window.audioPlayer) return;
        
        // 获取音量值（0-1范围）
        const volume = this.value / 100;
        
        // 设置音频播放器音量
        window.audioPlayer.volume = volume;
        window.audioPlayer.muted = false; // 确保不是静音
        
        // 更新音量图标
        updateVolumeIcon(volume);
    });
    
    // 更新音量图标
    function updateVolumeIcon(volume) {
        if (!volumeIcon) return;
        
        // 移除所有可能的音量类
        volumeIcon.classList.remove('fa-volume-up', 'fa-volume-down', 'fa-volume-off', 'fa-volume-mute');
        
        // 根据音量值设置图标
        if (volume > 0.7) {
            volumeIcon.classList.add('fa-volume-up');
        } else if (volume > 0.3) {
            volumeIcon.classList.add('fa-volume-down');
        } else if (volume > 0) {
            volumeIcon.classList.add('fa-volume-off');
        } else {
            volumeIcon.classList.add('fa-volume-mute');
        }
    }
    
    // 显示/隐藏音量控制
    volumeBtn.addEventListener('mouseenter', function() {
        volumeControl.style.display = 'flex';
    });
    
    volumeControl.addEventListener('mouseleave', function() {
        volumeControl.style.display = 'none';
    });
}

// 播放上一首曲目
function playPreviousTrack() {
    if (window.playlistManager) {
        window.playlistManager.previous();
    } else {
        console.log('播放列表管理器未初始化');
    }
}

// 播放下一首曲目
function playNextTrack() {
    if (window.playlistManager) {
        window.playlistManager.next();
    } else {
        console.log('播放列表管理器未初始化');
    }
}

// 切换播放/暂停状态
function togglePlayPause(forcePlay) {
    const playPauseBtn = document.querySelector('.play-pause');
    if (!playPauseBtn) return;
    
    const icon = playPauseBtn.querySelector('i');
    if (!icon) return;
    
    const isPlaying = icon.classList.contains('fa-pause');
    
    if (forcePlay === true || !isPlaying) {
        // 开始播放
        icon.classList.remove('fa-play');
        icon.classList.add('fa-pause');
        
        // 实际的音频播放逻辑
        if (window.audioPlayer) {
            window.audioPlayer.play().catch(e => {
                console.log("播放失败，可能需要用户交互:", e);
                // 播放失败时恢复图标
                icon.classList.remove('fa-pause');
                icon.classList.add('fa-play');
            });
        } else {
            // 如果播放器不存在，创建一个
            const audioPlayer = new Audio();
            window.audioPlayer = audioPlayer;
            
            // 设置默认音频源（从当前正在播放的卡片获取或使用默认音频）
            audioPlayer.src = window.currentAudioSrc || 'assets/music/qingtian.mp3';
            audioPlayer.volume = 0.7; // 默认音量
            
            // 播放并处理错误
            audioPlayer.play().catch(e => {
                console.log("播放失败，可能需要用户交互:", e);
                icon.classList.remove('fa-pause');
                icon.classList.add('fa-play');
            });
        }
        
        console.log('开始播放');
    } else {
        // 暂停播放
        icon.classList.remove('fa-pause');
        icon.classList.add('fa-play');
        
        // 实际的音频暂停逻辑
        if (window.audioPlayer) {
            window.audioPlayer.pause();
        }
        
        console.log('暂停播放');
    }
}

// 初始化顶部栏滚动隐藏
function initTopBarScrollHandling() {
    const contentContainer = document.querySelector('.content-container');
    const topBar = document.querySelector('.top-bar');
    
    if (!contentContainer || !topBar) return;
    
    let lastScrollTop = 0;
    
    contentContainer.addEventListener('scroll', function() {
        const scrollTop = this.scrollTop;
        
        // 向下滚动超过50px时隐藏顶部栏
        if (scrollTop > 50 && scrollTop > lastScrollTop) {
            topBar.classList.remove('visible');
        } else {
            // 向上滚动或在顶部附近时显示顶部栏
            topBar.classList.add('visible');
        }
        
        lastScrollTop = scrollTop;
    });
    
    // 初始时显示顶部栏
    topBar.classList.add('visible');
}

// 检查登录状态
function checkLoginStatus() {
    // 从localStorage获取当前用户
    const currentUserJson = localStorage.getItem('shengpotian_current_user');
    
    // 获取库内容和空状态消息
    const playlistsTab = document.querySelector('.playlists-tab');
    const artistsTab = document.querySelector('.artists-tab');
    const albumsTab = document.querySelector('.albums-tab');
    
    if (!currentUserJson) {
        // 未登录状态 - 显示登录提示
        console.log('用户未登录，显示登录提示');
        
        // 只有在存在内容标签时才添加登录提示
        if (playlistsTab) {
            // 创建登录提示
            createLoginPrompt(playlistsTab);
        }
        
        if (artistsTab) {
            createLoginPrompt(artistsTab);
        }
        
        if (albumsTab) {
            createLoginPrompt(albumsTab);
        }
    }
}

// 创建登录提示
function createLoginPrompt(container) {
    // 保存原始内容
    const originalContent = container.innerHTML;
    container.setAttribute('data-original-content', originalContent);
    
    // 更新i18n标签
    if (window.i18n) {
        window.i18n.updatePageLanguage();
    }
}

// 初始化进度条
function initProgressBar() {
    // 确保进度条元素存在
    const progressBar = document.querySelector('.progress-bar');
    const progressFill = document.querySelector('.progress-fill');
    
    if (!progressBar || !progressFill) return;
    
    // 确保音频播放器存在
    if (!window.audioPlayer) return;
    
    // 监听音频时间更新事件
    window.audioPlayer.addEventListener('timeupdate', updateProgress);
    
    // 进度条点击事件
    progressBar.addEventListener('click', function(e) {
        // 计算点击位置对应的时间比例
        const rect = this.getBoundingClientRect();
        const pos = (e.clientX - rect.left) / rect.width;
        
        // 更新进度条显示
        progressFill.style.width = (pos * 100) + '%';
        
        // 更新音频播放位置
        window.audioPlayer.currentTime = pos * window.audioPlayer.duration;
    });
    
    // 更新进度条显示
    function updateProgress() {
        // 计算当前进度比例
        const progress = (window.audioPlayer.currentTime / window.audioPlayer.duration) || 0;
        
        // 更新进度条填充
        progressFill.style.width = (progress * 100) + '%';
        
        // 更新时间显示
        updateTimeDisplay();
    }
    
    // 更新时间显示
    function updateTimeDisplay() {
        const currentTime = document.querySelector('.current-time');
        const totalTime = document.querySelector('.total-time');
        
        if (currentTime) {
            currentTime.textContent = formatTime(window.audioPlayer.currentTime);
        }
        
        if (totalTime) {
            totalTime.textContent = formatTime(window.audioPlayer.duration);
        }
    }
    
    // 格式化时间显示
    function formatTime(seconds) {
        if (isNaN(seconds)) return '0:00';
        
        const minutes = Math.floor(seconds / 60);
        const secs = Math.floor(seconds % 60);
        return `${minutes}:${secs < 10 ? '0' : ''}${secs}`;
    }
} 